import java.util.Scanner;

class Node2 {
    int val;
    Node2 next;
    public Node2(int val) {
        this.val = val;
    }
}
public class demo {
//    猴子分桃▲▲▲▲
//老猴子辛苦了一辈子，给那群小猴子们留下了一笔巨大的财富——一大堆桃子。老猴子决定把这些桃子分给小猴子。
//第一个猴子来了，它把桃子分成五堆，五堆一样多，但还多出一个。它把剩下的一个留给老猴子，自己拿走其中的一堆。
//第二个猴子来了，它把桃子分成五堆，五堆一样多，但又多出一个。它把多出的一个留给老猴子，自己拿走其中的一堆。
//后来的小猴子都如此照办。最后剩下的桃子全部留给老猴子。
//这里有n只小猴子，请你写个程序计算一下在开始时至少有多少个桃子，以及最后老猴子最少能得到几个桃子。
//  每组测试数据包括一个整数n(1≤n≤20)。

    /**
     * 思路：因为每次分5堆都会多出来1个，所以我们借给猴子们4个，以致每次都可以刚好分成5堆
     *   并且，每次给老猴子的桃子都不在我们借出的那4个中，这样最后减掉4就可以得到结果。
     *   在这里，有人可能会有疑问：给老猴子的那个桃子去哪里呢？其实，小猴子拿的那一部分就包括了这一个桃子，并且小猴子也没有多得桃子，
     *   假设最初由x个桃子，我们借给猴子4个，则此时有x+4个，
     *   第一个猴子得到（x+4）/5，剩余（x+4）*（4/5）个
     *   第二个猴子分完后剩余（x+4）*(4/5)^2个
     *   第三个猴子分完后剩余（x+4）*(4/5)^3个
     *   依次类推，最后一个猴子分完后剩余（x+4）*（4/5）^n
     *   要满足最后剩余的为整数，并且x最小，则当 x+4=5^n时，满足要求
     *   此时，x=5^n-4;
     *   老猴子得到的数量为：old = （x+4）*（4/5）^n + n - 4
     *                     = 4^n + n - 4
     *   最后老猴子减4是还给我们借给它们的那4个
     */
    public static void main1(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int n = in.nextInt();
            if (n == 0) {
                break;
            }
//            这里使用int会导致范围不够
            long a = (long)Math.pow(5,n);
            long b = (long)Math.pow(4,n);
            System.out.println(a-4+" "+(b+n-4));
        }
    }




//      nextLine方式输入的字符串可以含有空格，也就是说它是以回车作为输入的结束符。
//      next输入的字符串不能含有空格，它以空格、tab、回车作为输入的结束符。






    //  反转部分单向链表:▲▲▲▲▲
//      n 表示单链表的长度。
//      val 表示单链表各个节点的值。
//      L 表示翻转区间的左端点。
//      R 表示翻转区间的右端点。
//    输入
//5
//1 2 3 4 5
//1 3
//    输出
//3 2 1 4 5
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
//        吃掉n产生的换行符
        in.nextLine();
        String str = in.nextLine();
        int left = in.nextInt();
        int right = in.nextInt();
        String[] strVal = str.split(" ");
        Node2 dummyHead = new Node2(-1);
        Node2 cur = dummyHead;
        for (int i=0; i<n; i++) {
//            cur.next = new Node2(strVal[i]);error  需要将string类型先转换成int类型
            Node2 node2 = new Node2(Integer.parseInt(strVal[i]));//获取left和right也可以用String接收然后再转换
            cur.next = node2;
            cur = node2;
        }
        Node2 newHead = reverse(dummyHead.next, left, right);
        while (newHead != null) {
            System.out.print(newHead.val+" ");
            newHead = newHead.next;
        }
    }

    public static Node2 reverse(Node2 head, int left, int right) {
        Node2 dummyHead = new Node2(-1);
        dummyHead.next = head;
        Node2 pre = dummyHead;
//        找到需要反转最前面值的前驱
        for (int i=0; i<left-1; i++) {
            pre = pre.next;
        }
        Node2 cur = pre.next;

        for (int i=0; i<right-left; i++) {
            Node2 third = cur.next;
//            先将third从链表中删除
            cur.next = third.next;
//            在将third用插人到pre后(头插法)△
//            这里不要从pre中获取next 不能third.next=cur;pre.next=third; 因为cur一直都不变
            third.next = pre.next;
            pre.next = third;
        }
        return dummyHead.next;
    }

}

